home *** CD-ROM | disk | FTP | other *** search
/ Windows News 2005 November / WNnov2005.iso / Windows / Equipement / hMailServer / hMailServer-4.1-Build-136.exe / {app} / PHPWebAdmin / include / smarty / Smarty_Compiler.class.php < prev    next >
PHP Script  |  2004-10-24  |  91KB  |  2,257 lines
  1. <?php
  2.  
  3. /**
  4.  * Project:     Smarty: the PHP compiling template engine
  5.  * File:        Smarty_Compiler.class.php
  6.  *
  7.  * This library is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * This library is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with this library; if not, write to the Free Software
  19.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20.  *
  21.  * @link http://smarty.php.net/
  22.  * @author Monte Ohrt <monte@ispi.net>
  23.  * @author Andrei Zmievski <andrei@php.net>
  24.  * @version 2.6.5-dev
  25.  * @copyright 2001-2004 ispi of Lincoln, Inc.
  26.  * @package Smarty
  27.  */
  28.  
  29. /* $Id: Smarty_Compiler.class.php,v 1.1 2004/10/24 20:24:25 rabol Exp $ */
  30.  
  31. /**
  32.  * Template compiling class
  33.  * @package Smarty
  34.  */
  35. class Smarty_Compiler extends Smarty {
  36.  
  37.     // internal vars
  38.     /**#@+
  39.      * @access private
  40.      */
  41.     var $_folded_blocks         =   array();    // keeps folded template blocks
  42.     var $_current_file          =   null;       // the current template being compiled
  43.     var $_current_line_no       =   1;          // line number for error messages
  44.     var $_capture_stack         =   array();    // keeps track of nested capture buffers
  45.     var $_plugin_info           =   array();    // keeps track of plugins to load
  46.     var $_init_smarty_vars      =   false;
  47.     var $_permitted_tokens      =   array('true','false','yes','no','on','off','null');
  48.     var $_db_qstr_regexp        =   null;        // regexps are setup in the constructor
  49.     var $_si_qstr_regexp        =   null;
  50.     var $_qstr_regexp           =   null;
  51.     var $_func_regexp           =   null;
  52.     var $_var_bracket_regexp    =   null;
  53.     var $_dvar_guts_regexp      =   null;
  54.     var $_dvar_regexp           =   null;
  55.     var $_cvar_regexp           =   null;
  56.     var $_svar_regexp           =   null;
  57.     var $_avar_regexp           =   null;
  58.     var $_mod_regexp            =   null;
  59.     var $_var_regexp            =   null;
  60.     var $_parenth_param_regexp  =   null;
  61.     var $_func_call_regexp      =   null;
  62.     var $_obj_ext_regexp        =   null;
  63.     var $_obj_start_regexp      =   null;
  64.     var $_obj_params_regexp     =   null;
  65.     var $_obj_call_regexp       =   null;
  66.     var $_cacheable_state       =   0;
  67.     var $_cache_attrs_count     =   0;
  68.     var $_nocache_count         =   0;
  69.     var $_cache_serial          =   null;
  70.     var $_cache_include         =   null;
  71.  
  72.     var $_strip_depth           =   0;
  73.     var $_additional_newline    =   "\n";
  74.  
  75.     /**#@-*/
  76.     /**
  77.      * The class constructor.
  78.      */
  79.     function Smarty_Compiler()
  80.     {
  81.         // matches double quoted strings:
  82.         // "foobar"
  83.         // "foo\"bar"
  84.         $this->_db_qstr_regexp = '"[^"\\\\]*(?:\\\\.[^"\\\\]*)*"';
  85.  
  86.         // matches single quoted strings:
  87.         // 'foobar'
  88.         // 'foo\'bar'
  89.         $this->_si_qstr_regexp = '\'[^\'\\\\]*(?:\\\\.[^\'\\\\]*)*\'';
  90.  
  91.         // matches single or double quoted strings
  92.         $this->_qstr_regexp = '(?:' . $this->_db_qstr_regexp . '|' . $this->_si_qstr_regexp . ')';
  93.  
  94.         // matches bracket portion of vars
  95.         // [0]
  96.         // [foo]
  97.         // [$bar]
  98.         $this->_var_bracket_regexp = '\[\$?[\w\.]+\]';
  99.  
  100.         // matches numerical constants
  101.         // 30
  102.         // -12
  103.         // 13.22
  104.         $this->_num_const_regexp = '\-?\d+(?:\.\d+)?';
  105.  
  106.         // matches $ vars (not objects):
  107.         // $foo
  108.         // $foo.bar
  109.         // $foo.bar.foobar
  110.         // $foo[0]
  111.         // $foo[$bar]
  112.         // $foo[5][blah]
  113.         // $foo[5].bar[$foobar][4]
  114.         $this->_dvar_math_regexp = '(?:[\+\*\/\%]|(?:-(?!>)))';
  115.         $this->_dvar_math_var_regexp = '[\$\w\.\+\-\*\/\%\d\>\[\]]';
  116.         $this->_dvar_guts_regexp = '\w+(?:' . $this->_var_bracket_regexp
  117.                 . ')*(?:\.\$?\w+(?:' . $this->_var_bracket_regexp . ')*)*(?:' . $this->_dvar_math_regexp . '(?:' . $this->_num_const_regexp . '|' . $this->_dvar_math_var_regexp . ')*)?';
  118.         $this->_dvar_regexp = '\$' . $this->_dvar_guts_regexp;
  119.  
  120.         // matches config vars:
  121.         // #foo#
  122.         // #foobar123_foo#
  123.         $this->_cvar_regexp = '\#\w+\#';
  124.  
  125.         // matches section vars:
  126.         // %foo.bar%
  127.         $this->_svar_regexp = '\%\w+\.\w+\%';
  128.  
  129.         // matches all valid variables (no quotes, no modifiers)
  130.         $this->_avar_regexp = '(?:' . $this->_dvar_regexp . '|'
  131.            . $this->_cvar_regexp . '|' . $this->_svar_regexp . ')';
  132.  
  133.         // matches valid variable syntax:
  134.         // $foo
  135.         // $foo
  136.         // #foo#
  137.         // #foo#
  138.         // "text"
  139.         // "text"
  140.         $this->_var_regexp = '(?:' . $this->_avar_regexp . '|' . $this->_num_const_regexp . '|' . $this->_qstr_regexp . ')';
  141.  
  142.         // matches valid object call (one level of object nesting allowed in parameters):
  143.         // $foo->bar
  144.         // $foo->bar()
  145.         // $foo->bar("text")
  146.         // $foo->bar($foo, $bar, "text")
  147.         // $foo->bar($foo, "foo")
  148.         // $foo->bar->foo()
  149.         // $foo->bar->foo->bar()
  150.         // $foo->bar($foo->bar)
  151.         // $foo->bar($foo->bar())
  152.         // $foo->bar($foo->bar($blah,$foo,44,"foo",$foo[0].bar))
  153.         $this->_obj_ext_regexp = '\->(?:\$?' . $this->_dvar_guts_regexp . ')';
  154.         $this->_obj_restricted_param_regexp = '(?:'
  155.                 . $this->_var_regexp . '(?:' . $this->_obj_ext_regexp . '(?:\((?:' . $this->_var_regexp
  156.                 . '(?:\s*,\s*' . $this->_var_regexp . ')*)?\))?)*)';
  157.         $this->_obj_single_param_regexp = '(?:\w+|' . $this->_obj_restricted_param_regexp . '(?:\s*,\s*(?:(?:\w+|'
  158.                 . $this->_var_regexp . $this->_obj_restricted_param_regexp . ')))*)';
  159.         $this->_obj_params_regexp = '\((?:' . $this->_obj_single_param_regexp
  160.                 . '(?:\s*,\s*' . $this->_obj_single_param_regexp . ')*)?\)';
  161.         $this->_obj_start_regexp = '(?:' . $this->_dvar_regexp . '(?:' . $this->_obj_ext_regexp . ')+)';
  162.         $this->_obj_call_regexp = '(?:' . $this->_obj_start_regexp . '(?:' . $this->_obj_params_regexp . ')?(?:' . $this->_dvar_math_regexp . '(?:' . $this->_num_const_regexp . '|' . $this->_dvar_math_var_regexp . ')*)?)';
  163.         
  164.         // matches valid modifier syntax:
  165.         // |foo
  166.         // |@foo
  167.         // |foo:"bar"
  168.         // |foo:$bar
  169.         // |foo:"bar":$foobar
  170.         // |foo|bar
  171.         // |foo:$foo->bar
  172.         $this->_mod_regexp = '(?:\|@?\w+(?::(?>-?\w+|'
  173.            . $this->_obj_call_regexp . '|' . $this->_avar_regexp . '|' . $this->_qstr_regexp .'))*)';
  174.  
  175.         // matches valid function name:
  176.         // foo123
  177.         // _foo_bar
  178.         $this->_func_regexp = '[a-zA-Z_]\w*';
  179.  
  180.         // matches valid registered object:
  181.         // foo->bar
  182.         $this->_reg_obj_regexp = '[a-zA-Z_]\w*->[a-zA-Z_]\w*';
  183.  
  184.         // matches valid parameter values:
  185.         // true
  186.         // $foo
  187.         // $foo|bar
  188.         // #foo#
  189.         // #foo#|bar
  190.         // "text"
  191.         // "text"|bar
  192.         // $foo->bar
  193.         $this->_param_regexp = '(?:\s*(?:' . $this->_obj_call_regexp . '|'
  194.            . $this->_var_regexp  . '|\w+)(?>' . $this->_mod_regexp . '*)\s*)';
  195.  
  196.         // matches valid parenthesised function parameters:
  197.         //
  198.         // "text"
  199.         //    $foo, $bar, "text"
  200.         // $foo|bar, "foo"|bar, $foo->bar($foo)|bar
  201.         $this->_parenth_param_regexp = '(?:\((?:\w+|'
  202.                 . $this->_param_regexp . '(?:\s*,\s*(?:(?:\w+|'
  203.                 . $this->_param_regexp . ')))*)?\))';
  204.  
  205.         // matches valid function call:
  206.         // foo()
  207.         // foo_bar($foo)
  208.         // _foo_bar($foo,"bar")
  209.         // foo123($foo,$foo->bar(),"foo")
  210.         $this->_func_call_regexp = '(?:' . $this->_func_regexp . '\s*(?:'
  211.            . $this->_parenth_param_regexp . '))';
  212.     }
  213.  
  214.     /**
  215.      * compile a resource
  216.      *
  217.      * sets $compiled_content to the compiled source
  218.      * @param string $resource_name
  219.      * @param string $source_content
  220.      * @param string $compiled_content
  221.      * @return true
  222.      */
  223.     function _compile_file($resource_name, $source_content, &$compiled_content)
  224.     {
  225.  
  226.         if ($this->security) {
  227.             // do not allow php syntax to be executed unless specified
  228.             if ($this->php_handling == SMARTY_PHP_ALLOW &&
  229.                 !$this->security_settings['PHP_HANDLING']) {
  230.                 $this->php_handling = SMARTY_PHP_PASSTHRU;
  231.             }
  232.         }
  233.  
  234.         $this->_load_filters();
  235.  
  236.         $this->_current_file = $resource_name;
  237.         $this->_current_line_no = 1;
  238.         $ldq = preg_quote($this->left_delimiter, '~');
  239.         $rdq = preg_quote($this->right_delimiter, '~');
  240.  
  241.         // run template source through prefilter functions
  242.         if (count($this->_plugins['prefilter']) > 0) {
  243.             foreach ($this->_plugins['prefilter'] as $filter_name => $prefilter) {
  244.                 if ($prefilter === false) continue;
  245.                 if ($prefilter[3] || is_callable($prefilter[0])) {
  246.                     $source_content = call_user_func_array($prefilter[0],
  247.                                                             array($source_content, &$this));
  248.                     $this->_plugins['prefilter'][$filter_name][3] = true;
  249.                 } else {
  250.                     $this->_trigger_fatal_error("[plugin] prefilter '$filter_name' is not implemented");
  251.                 }
  252.             }
  253.         }
  254.  
  255.         /* fetch all special blocks */
  256.         $search = "~{$ldq}\*(.*?)\*{$rdq}|{$ldq}\s*literal\s*{$rdq}(.*?){$ldq}\s*/literal\s*{$rdq}|{$ldq}\s*php\s*{$rdq}(.*?){$ldq}\s*/php\s*{$rdq}~s";
  257.  
  258.         preg_match_all($search, $source_content, $match,  PREG_SET_ORDER);
  259.         $this->_folded_blocks = $match;
  260.         reset($this->_folded_blocks);
  261.  
  262.         /* replace special blocks by "{php}" */
  263.         $source_content = preg_replace($search.'e', "'"
  264.                                        . $this->_quote_replace($this->left_delimiter) . 'php'
  265.                                        . "' . str_repeat(\"\n\", substr_count('\\0', \"\n\")) .'"
  266.                                        . $this->_quote_replace($this->right_delimiter)
  267.                                        . "'"
  268.                                        , $source_content);
  269.  
  270.         /* Gather all template tags. */
  271.         preg_match_all("~{$ldq}\s*(.*?)\s*{$rdq}~s", $source_content, $_match);
  272.         $template_tags = $_match[1];
  273.         /* Split content by template tags to obtain non-template content. */
  274.         $text_blocks = preg_split("~{$ldq}.*?{$rdq}~s", $source_content);
  275.  
  276.         /* loop through text blocks */
  277.         for ($curr_tb = 0, $for_max = count($text_blocks); $curr_tb < $for_max; $curr_tb++) {
  278.             /* match anything resembling php tags */
  279.             if (preg_match_all('~(<\?(?:\w+|=)?|\?>|language\s*=\s*[\"\']?php[\"\']?)~is', $text_blocks[$curr_tb], $sp_match)) {
  280.                 /* replace tags with placeholders to prevent recursive replacements */
  281.                 $sp_match[1] = array_unique($sp_match[1]);
  282.                 usort($sp_match[1], '_smarty_sort_length');
  283.                 for ($curr_sp = 0, $for_max2 = count($sp_match[1]); $curr_sp < $for_max2; $curr_sp++) {
  284.                     $text_blocks[$curr_tb] = str_replace($sp_match[1][$curr_sp],'%%%SMARTYSP'.$curr_sp.'%%%',$text_blocks[$curr_tb]);
  285.                 }
  286.                 /* process each one */
  287.                 for ($curr_sp = 0, $for_max2 = count($sp_match[1]); $curr_sp < $for_max2; $curr_sp++) {
  288.                     if ($this->php_handling == SMARTY_PHP_PASSTHRU) {
  289.                         /* echo php contents */
  290.                         $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP'.$curr_sp.'%%%', '<?php echo \''.str_replace("'", "\'", $sp_match[1][$curr_sp]).'\'; ?>'."\n", $text_blocks[$curr_tb]);
  291.                     } else if ($this->php_handling == SMARTY_PHP_QUOTE) {
  292.                         /* quote php tags */
  293.                         $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP'.$curr_sp.'%%%', htmlspecialchars($sp_match[1][$curr_sp]), $text_blocks[$curr_tb]);
  294.                     } else if ($this->php_handling == SMARTY_PHP_REMOVE) {
  295.                         /* remove php tags */
  296.                         $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP'.$curr_sp.'%%%', '', $text_blocks[$curr_tb]);
  297.                     } else {
  298.                         /* SMARTY_PHP_ALLOW, but echo non php starting tags */
  299.                         $sp_match[1][$curr_sp] = preg_replace('~(<\?(?!php|=|$))~i', '<?php echo \'\\1\'?>'."\n", $sp_match[1][$curr_sp]);
  300.                         $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP'.$curr_sp.'%%%', $sp_match[1][$curr_sp], $text_blocks[$curr_tb]);
  301.                     }
  302.                 }
  303.             }
  304.         }
  305.  
  306.         /* Compile the template tags into PHP code. */
  307.         $compiled_tags = array();
  308.         for ($i = 0, $for_max = count($template_tags); $i < $for_max; $i++) {
  309.             $this->_current_line_no += substr_count($text_blocks[$i], "\n");
  310.             $compiled_tags[] = $this->_compile_tag($template_tags[$i]);
  311.             $this->_current_line_no += substr_count($template_tags[$i], "\n");
  312.         }
  313.         if (count($this->_tag_stack)>0) {
  314.             list($_open_tag, $_line_no) = end($this->_tag_stack);
  315.             $this->_syntax_error("unclosed tag \{$_open_tag} (opened line $_line_no).", E_USER_ERROR, __FILE__, __LINE__);
  316.             return;
  317.         }
  318.  
  319.         $compiled_content = '';
  320.  
  321.         /* Interleave the compiled contents and text blocks to get the final result. */
  322.         for ($i = 0, $for_max = count($compiled_tags); $i < $for_max; $i++) {
  323.             if ($compiled_tags[$i] == '') {
  324.                 // tag result empty, remove first newline from following text block
  325.                 $text_blocks[$i+1] = preg_replace('~^(\r\n|\r|\n)~', '', $text_blocks[$i+1]);
  326.             }
  327.             $compiled_content .= $text_blocks[$i].$compiled_tags[$i];
  328.         }
  329.         $compiled_content .= $text_blocks[$i];
  330.  
  331.         /* Reformat data between 'strip' and '/strip' tags, removing spaces, tabs and newlines. */
  332.         if (preg_match_all("~{$ldq}strip{$rdq}.*?{$ldq}/strip{$rdq}~s", $compiled_content, $_match)) {
  333.             $strip_tags = $_match[0];
  334.             $strip_tags_modified = preg_replace("~{$ldq}/?strip{$rdq}|[\t ]+$|^[\t ]+~m", '', $strip_tags);
  335.             $strip_tags_modified = preg_replace('~[\r\n]+~m', '', $strip_tags_modified);
  336.             for ($i = 0, $for_max = count($strip_tags); $i < $for_max; $i++)
  337.                 $compiled_content = preg_replace("~{$ldq}strip{$rdq}.*?{$ldq}/strip{$rdq}~s",
  338.                                                   $this->_quote_replace($strip_tags_modified[$i]),
  339.                                                   $compiled_content, 1);
  340.         }
  341.  
  342.         // remove \n from the end of the file, if any
  343.         if (($_len=strlen($compiled_content)) && ($compiled_content{$_len - 1} == "\n" )) {
  344.             $compiled_content = substr($compiled_content, 0, -1);
  345.         }
  346.  
  347.         if (!empty($this->_cache_serial)) {
  348.             $compiled_content = "<?php \$this->_cache_serials['".$this->_cache_include."'] = '".$this->_cache_serial."'; ?>" . $compiled_content;
  349.         }
  350.  
  351.         // remove unnecessary close/open tags
  352.         $compiled_content = preg_replace('~\?>\n?<\?php~', '', $compiled_content);
  353.  
  354.         // run compiled template through postfilter functions
  355.         if (count($this->_plugins['postfilter']) > 0) {
  356.             foreach ($this->_plugins['postfilter'] as $filter_name => $postfilter) {
  357.                 if ($postfilter === false) continue;
  358.                 if ($postfilter[3] || is_callable($postfilter[0])) {
  359.                     $compiled_content = call_user_func_array($postfilter[0],
  360.                                                               array($compiled_content, &$this));
  361.                     $this->_plugins['postfilter'][$filter_name][3] = true;
  362.                 } else {
  363.                     $this->_trigger_fatal_error("Smarty plugin error: postfilter '$filter_name' is not implemented");
  364.                 }
  365.             }
  366.         }
  367.  
  368.         // put header at the top of the compiled template
  369.         $template_header = "<?php /* Smarty version ".$this->_version.", created on ".strftime("%Y-%m-%d %H:%M:%S")."\n";
  370.         $template_header .= "         compiled from ".strtr(urlencode($resource_name), array('%2F'=>'/', '%3A'=>':'))." */ ?>\n";
  371.  
  372.         /* Emit code to load needed plugins. */
  373.         $this->_plugins_code = '';
  374.         if (count($this->_plugin_info)) {
  375.             $_plugins_params = "array('plugins' => array(";
  376.             foreach ($this->_plugin_info as $plugin_type => $plugins) {
  377.                 foreach ($plugins as $plugin_name => $plugin_info) {
  378.                     $_plugins_params .= "array('$plugin_type', '$plugin_name', '$plugin_info[0]', $plugin_info[1], ";
  379.                     $_plugins_params .= $plugin_info[2] ? 'true),' : 'false),';
  380.                 }
  381.             }
  382.             $_plugins_params .= '))';
  383.             $plugins_code = "<?php require_once(SMARTY_DIR . 'core' . DIRECTORY_SEPARATOR . 'core.load_plugins.php');\nsmarty_core_load_plugins($_plugins_params, \$this); ?>\n";
  384.             $template_header .= $plugins_code;
  385.             $this->_plugin_info = array();
  386.             $this->_plugins_code = $plugins_code;
  387.         }
  388.  
  389.         if ($this->_init_smarty_vars) {
  390.             $template_header .= "<?php require_once(SMARTY_DIR . 'core' . DIRECTORY_SEPARATOR . 'core.assign_smarty_interface.php');\nsmarty_core_assign_smarty_interface(null, \$this); ?>\n";
  391.             $this->_init_smarty_vars = false;
  392.         }
  393.  
  394.         $compiled_content = $template_header . $compiled_content;
  395.         return true;
  396.     }
  397.  
  398.     /**
  399.      * Compile a template tag
  400.      *
  401.      * @param string $template_tag
  402.      * @return string
  403.      */
  404.     function _compile_tag($template_tag)
  405.     {
  406.         /* Matched comment. */
  407.         if ($template_tag{0} == '*' && $template_tag{strlen($template_tag) - 1} == '*')
  408.             return '';
  409.         
  410.         /* Split tag into two three parts: command, command modifiers and the arguments. */
  411.         if(! preg_match('~^(?:(' . $this->_num_const_regexp . '|' . $this->_obj_call_regexp . '|' . $this->_var_regexp
  412.                 . '|\/?' . $this->_reg_obj_regexp . '|\/?' . $this->_func_regexp . ')(' . $this->_mod_regexp . '*))
  413.                       (?:\s+(.*))?$
  414.                     ~xs', $template_tag, $match)) {
  415.             $this->_syntax_error("unrecognized tag: $template_tag", E_USER_ERROR, __FILE__, __LINE__);
  416.         }
  417.         
  418.         $tag_command = $match[1];
  419.         $tag_modifier = isset($match[2]) ? $match[2] : null;
  420.         $tag_args = isset($match[3]) ? $match[3] : null;
  421.  
  422.         if (preg_match('~^' . $this->_num_const_regexp . '|' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '$~', $tag_command)) {
  423.             /* tag name is a variable or object */
  424.             $_return = $this->_parse_var_props($tag_command . $tag_modifier, $this->_parse_attrs($tag_args));
  425.             if(isset($_tag_attrs['assign'])) {
  426.                 return "<?php \$this->assign('" . $this->_dequote($_tag_attrs['assign']) . "', $_return ); ?>\n";
  427.             } else {
  428.                 return "<?php echo $_return; ?>" . $this->_additional_newline;
  429.             }
  430.         }
  431.  
  432.         /* If the tag name is a registered object, we process it. */
  433.         if (preg_match('~^\/?' . $this->_reg_obj_regexp . '$~', $tag_command)) {
  434.             return $this->_compile_registered_object_tag($tag_command, $this->_parse_attrs($tag_args), $tag_modifier);
  435.         }
  436.  
  437.         switch ($tag_command) {
  438.             case 'include':
  439.                 return $this->_compile_include_tag($tag_args);
  440.  
  441.             case 'include_php':
  442.                 return $this->_compile_include_php_tag($tag_args);
  443.  
  444.             case 'if':
  445.                 $this->_push_tag('if');
  446.                 return $this->_compile_if_tag($tag_args);
  447.  
  448.             case 'else':
  449.                 list($_open_tag) = end($this->_tag_stack);
  450.                 if ($_open_tag != 'if' && $_open_tag != 'elseif')
  451.                     $this->_syntax_error('unexpected {else}', E_USER_ERROR, __FILE__, __LINE__);
  452.                 else
  453.                     $this->_push_tag('else');
  454.                 return '<?php else: ?>';
  455.  
  456.             case 'elseif':
  457.                 list($_open_tag) = end($this->_tag_stack);
  458.                 if ($_open_tag != 'if' && $_open_tag != 'elseif')
  459.                     $this->_syntax_error('unexpected {elseif}', E_USER_ERROR, __FILE__, __LINE__);
  460.                 if ($_open_tag == 'if')
  461.                     $this->_push_tag('elseif');
  462.                 return $this->_compile_if_tag($tag_args, true);
  463.  
  464.             case '/if':
  465.                 $this->_pop_tag('if');
  466.                 return '<?php endif; ?>';
  467.  
  468.             case 'capture':
  469.                 return $this->_compile_capture_tag(true, $tag_args);
  470.  
  471.             case '/capture':
  472.                 return $this->_compile_capture_tag(false);
  473.  
  474.             case 'ldelim':
  475.                 return $this->left_delimiter;
  476.  
  477.             case 'rdelim':
  478.                 return $this->right_delimiter;
  479.  
  480.             case 'section':
  481.                 $this->_push_tag('section');
  482.                 return $this->_compile_section_start($tag_args);
  483.  
  484.             case 'sectionelse':
  485.                 $this->_push_tag('sectionelse');
  486.                 return "<?php endfor; else: ?>";
  487.                 break;
  488.  
  489.             case '/section':
  490.                 $_open_tag = $this->_pop_tag('section');
  491.                 if ($_open_tag == 'sectionelse')
  492.                     return "<?php endif; ?>";
  493.                 else
  494.                     return "<?php endfor; endif; ?>";
  495.  
  496.             case 'foreach':
  497.                 $this->_push_tag('foreach');
  498.                 return $this->_compile_foreach_start($tag_args);
  499.                 break;
  500.  
  501.             case 'foreachelse':
  502.                 $this->_push_tag('foreachelse');
  503.                 return "<?php endforeach; unset(\$_from); else: ?>";
  504.  
  505.             case '/foreach':
  506.                 $_open_tag = $this->_pop_tag('foreach');
  507.                 if ($_open_tag == 'foreachelse')
  508.                     return "<?php endif; ?>";
  509.                 else
  510.                     return "<?php endforeach; unset(\$_from); endif; ?>";
  511.                 break;
  512.  
  513.             case 'strip':
  514.             case '/strip':
  515.                 if ($tag_command{0}=='/') {
  516.                     $this->_pop_tag('strip');
  517.                     if (--$this->_strip_depth==0) { /* outermost closing {/strip} */
  518.                         $this->_additional_newline = "\n";
  519.                         return $this->left_delimiter.$tag_command.$this->right_delimiter;
  520.                     }
  521.                 } else {
  522.                     $this->_push_tag('strip');
  523.                     if ($this->_strip_depth++==0) { /* outermost opening {strip} */
  524.                         $this->_additional_newline = "";
  525.                         return $this->left_delimiter.$tag_command.$this->right_delimiter;
  526.                     }
  527.                 }
  528.                 return '';
  529.  
  530.             case 'php':
  531.                 /* handle folded tags replaced by {php} */
  532.                 list(, $block) = each($this->_folded_blocks);
  533.                 $this->_current_line_no += substr_count($block[0], "\n");
  534.                 /* the number of matched elements in the regexp in _compile_file()
  535.                    determins the type of folded tag that was found */
  536.                 switch (count($block)) {
  537.                     case 2: /* comment */
  538.                         return '';
  539.  
  540.                     case 3: /* literal */
  541.                         return "<?php echo '" . strtr($block[2], array("'"=>"\'", "\\"=>"\\\\")) . "'; ?>" . $this->_additional_newline;
  542.  
  543.                     case 4: /* php */
  544.                         if ($this->security && !$this->security_settings['PHP_TAGS']) {
  545.                             $this->_syntax_error("(secure mode) php tags not permitted", E_USER_WARNING, __FILE__, __LINE__);
  546.                             return;
  547.                         }
  548.                         return '<?php ' . $block[3] .' ?>';
  549.                 }
  550.                 break;
  551.  
  552.             case 'insert':
  553.                 return $this->_compile_insert_tag($tag_args);
  554.  
  555.             default:
  556.                 if ($this->_compile_compiler_tag($tag_command, $tag_args, $output)) {
  557.                     return $output;
  558.                 } else if ($this->_compile_block_tag($tag_command, $tag_args, $tag_modifier, $output)) {
  559.                     return $output;
  560.                 } else if ($this->_compile_custom_tag($tag_command, $tag_args, $tag_modifier, $output)) {
  561.                     return $output;                    
  562.                 } else {
  563.                     $this->_syntax_error("unrecognized tag '$tag_command'", E_USER_ERROR, __FILE__, __LINE__);
  564.                 }
  565.  
  566.         }
  567.     }
  568.  
  569.  
  570.     /**
  571.      * compile the custom compiler tag
  572.      *
  573.      * sets $output to the compiled custom compiler tag
  574.      * @param string $tag_command
  575.      * @param string $tag_args
  576.      * @param string $output
  577.      * @return boolean
  578.      */
  579.     function _compile_compiler_tag($tag_command, $tag_args, &$output)
  580.     {
  581.         $found = false;
  582.         $have_function = true;
  583.  
  584.         /*
  585.          * First we check if the compiler function has already been registered
  586.          * or loaded from a plugin file.
  587.          */
  588.         if (isset($this->_plugins['compiler'][$tag_command])) {
  589.             $found = true;
  590.             $plugin_func = $this->_plugins['compiler'][$tag_command][0];
  591.             if (!is_callable($plugin_func)) {
  592.                 $message = "compiler function '$tag_command' is not implemented";
  593.                 $have_function = false;
  594.             }
  595.         }
  596.         /*
  597.          * Otherwise we need to load plugin file and look for the function
  598.          * inside it.
  599.          */
  600.         else if ($plugin_file = $this->_get_plugin_filepath('compiler', $tag_command)) {
  601.             $found = true;
  602.  
  603.             include_once $plugin_file;
  604.  
  605.             $plugin_func = 'smarty_compiler_' . $tag_command;
  606.             if (!is_callable($plugin_func)) {
  607.                 $message = "plugin function $plugin_func() not found in $plugin_file\n";
  608.                 $have_function = false;
  609.             } else {
  610.                 $this->_plugins['compiler'][$tag_command] = array($plugin_func, null, null, null, true);
  611.             }
  612.         }
  613.  
  614.         /*
  615.          * True return value means that we either found a plugin or a
  616.          * dynamically registered function. False means that we didn't and the
  617.          * compiler should now emit code to load custom function plugin for this
  618.          * tag.
  619.          */
  620.         if ($found) {
  621.             if ($have_function) {
  622.                 $output = call_user_func_array($plugin_func, array($tag_args, &$this));
  623.                 if($output != '') {
  624.                 $output = '<?php ' . $this->_push_cacheable_state('compiler', $tag_command)
  625.                                    . $output
  626.                                    . $this->_pop_cacheable_state('compiler', $tag_command) . ' ?>';
  627.                 }
  628.             } else {
  629.                 $this->_syntax_error($message, E_USER_WARNING, __FILE__, __LINE__);
  630.             }
  631.             return true;
  632.         } else {
  633.             return false;
  634.         }
  635.     }
  636.  
  637.  
  638.     /**
  639.      * compile block function tag
  640.      *
  641.      * sets $output to compiled block function tag
  642.      * @param string $tag_command
  643.      * @param string $tag_args
  644.      * @param string $tag_modifier
  645.      * @param string $output
  646.      * @return boolean
  647.      */
  648.     function _compile_block_tag($tag_command, $tag_args, $tag_modifier, &$output)
  649.     {
  650.         if ($tag_command{0} == '/') {
  651.             $start_tag = false;
  652.             $tag_command = substr($tag_command, 1);
  653.         } else
  654.             $start_tag = true;
  655.  
  656.         $found = false;
  657.         $have_function = true;
  658.  
  659.         /*
  660.          * First we check if the block function has already been registered
  661.          * or loaded from a plugin file.
  662.          */
  663.         if (isset($this->_plugins['block'][$tag_command])) {
  664.             $found = true;
  665.             $plugin_func = $this->_plugins['block'][$tag_command][0];
  666.             if (!is_callable($plugin_func)) {
  667.                 $message = "block function '$tag_command' is not implemented";
  668.                 $have_function = false;
  669.             }
  670.         }
  671.         /*
  672.          * Otherwise we need to load plugin file and look for the function
  673.          * inside it.
  674.          */
  675.         else if ($plugin_file = $this->_get_plugin_filepath('block', $tag_command)) {
  676.             $found = true;
  677.  
  678.             include_once $plugin_file;
  679.  
  680.             $plugin_func = 'smarty_block_' . $tag_command;
  681.             if (!function_exists($plugin_func)) {
  682.                 $message = "plugin function $plugin_func() not found in $plugin_file\n";
  683.                 $have_function = false;
  684.             } else {
  685.                 $this->_plugins['block'][$tag_command] = array($plugin_func, null, null, null, true);
  686.  
  687.             }
  688.         }
  689.  
  690.         if (!$found) {
  691.             return false;
  692.         } else if (!$have_function) {
  693.             $this->_syntax_error($message, E_USER_WARNING, __FILE__, __LINE__);
  694.             return true;
  695.         }
  696.  
  697.         /*
  698.          * Even though we've located the plugin function, compilation
  699.          * happens only once, so the plugin will still need to be loaded
  700.          * at runtime for future requests.
  701.          */
  702.         $this->_add_plugin('block', $tag_command);
  703.  
  704.         if ($start_tag)
  705.             $this->_push_tag($tag_command);
  706.         else
  707.             $this->_pop_tag($tag_command);
  708.  
  709.         if ($start_tag) {
  710.             $output = '<?php ' . $this->_push_cacheable_state('block', $tag_command);
  711.             $attrs = $this->_parse_attrs($tag_args);
  712.             $arg_list = $this->_compile_arg_list('block', $tag_command, $attrs, $_cache_attrs='');
  713.             $output .= "$_cache_attrs\$this->_tag_stack[] = array('$tag_command', array(".implode(',', $arg_list).')); ';
  714.             $output .= $this->_compile_plugin_call('block', $tag_command).'($this->_tag_stack[count($this->_tag_stack)-1][1], null, $this, $_block_repeat=true);';
  715.             $output .= 'while ($_block_repeat) { ob_start(); ?>';
  716.         } else {
  717.             $output = '<?php $this->_block_content = ob_get_contents(); ob_end_clean(); ';
  718.             $_out_tag_text = $this->_compile_plugin_call('block', $tag_command).'($this->_tag_stack[count($this->_tag_stack)-1][1], $this->_block_content, $this, $_block_repeat=false)';
  719.             if ($tag_modifier != '') {
  720.                 $this->_parse_modifiers($_out_tag_text, $tag_modifier);
  721.             }
  722.             $output .= 'echo '.$_out_tag_text.'; } ';
  723.             $output .= " array_pop(\$this->_tag_stack); " . $this->_pop_cacheable_state('block', $tag_command) . '?>';
  724.         }
  725.  
  726.         return true;
  727.     }
  728.  
  729.  
  730.     /**
  731.      * compile custom function tag
  732.      *
  733.      * @param string $tag_command
  734.      * @param string $tag_args
  735.      * @param string $tag_modifier
  736.      * @return string
  737.      */
  738.     function _compile_custom_tag($tag_command, $tag_args, $tag_modifier, &$output)
  739.     {
  740.         $found = false;
  741.         $have_function = true;
  742.  
  743.         /*
  744.          * First we check if the custom function has already been registered
  745.          * or loaded from a plugin file.
  746.          */
  747.         if (isset($this->_plugins['function'][$tag_command])) {
  748.             $found = true;
  749.             $plugin_func = $this->_plugins['function'][$tag_command][0];
  750.             if (!is_callable($plugin_func)) {
  751.                 $message = "custom function '$tag_command' is not implemented";
  752.                 $have_function = false;
  753.             }
  754.         }
  755.         /*
  756.          * Otherwise we need to load plugin file and look for the function
  757.          * inside it.
  758.          */
  759.         else if ($plugin_file = $this->_get_plugin_filepath('function', $tag_command)) {
  760.             $found = true;
  761.  
  762.             include_once $plugin_file;
  763.  
  764.             $plugin_func = 'smarty_function_' . $tag_command;
  765.             if (!function_exists($plugin_func)) {
  766.                 $message = "plugin function $plugin_func() not found in $plugin_file\n";
  767.                 $have_function = false;
  768.             } else {
  769.                 $this->_plugins['function'][$tag_command] = array($plugin_func, null, null, null, true);
  770.  
  771.             }
  772.         }
  773.  
  774.         if (!$found) {
  775.             return false;
  776.         } else if (!$have_function) {
  777.             $this->_syntax_error($message, E_USER_WARNING, __FILE__, __LINE__);
  778.             return true;
  779.         }
  780.  
  781.         /* declare plugin to be loaded on display of the template that
  782.            we compile right now */
  783.         $this->_add_plugin('function', $tag_command);
  784.  
  785.         $_cacheable_state = $this->_push_cacheable_state('function', $tag_command);
  786.         $attrs = $this->_parse_attrs($tag_args);
  787.         $arg_list = $this->_compile_arg_list('function', $tag_command, $attrs, $_cache_attrs='');
  788.  
  789.         $output = $this->_compile_plugin_call('function', $tag_command).'(array('.implode(',', $arg_list)."), \$this)";
  790.         if($tag_modifier != '') {
  791.             $this->_parse_modifiers($output, $tag_modifier);
  792.         }
  793.  
  794.         if($output != '') {
  795.             $output =  '<?php ' . $_cacheable_state . $_cache_attrs . 'echo ' . $output . ';'
  796.                 . $this->_pop_cacheable_state('function', $tag_command) . "?>" . $this->_additional_newline;
  797.         }
  798.  
  799.         return true;
  800.     }
  801.  
  802.     /**
  803.      * compile a registered object tag
  804.      *
  805.      * @param string $tag_command
  806.      * @param array $attrs
  807.      * @param string $tag_modifier
  808.      * @return string
  809.      */
  810.     function _compile_registered_object_tag($tag_command, $attrs, $tag_modifier)
  811.     {
  812.         if ($tag_command{0} == '/') {
  813.             $start_tag = false;
  814.             $tag_command = substr($tag_command, 1);
  815.         } else {
  816.             $start_tag = true;
  817.         }
  818.  
  819.         list($object, $obj_comp) = explode('->', $tag_command);
  820.  
  821.         $arg_list = array();
  822.         if(count($attrs)) {
  823.             $_assign_var = false;
  824.             foreach ($attrs as $arg_name => $arg_value) {
  825.                 if($arg_name == 'assign') {
  826.                     $_assign_var = $arg_value;
  827.                     unset($attrs['assign']);
  828.                     continue;
  829.                 }
  830.                 if (is_bool($arg_value))
  831.                     $arg_value = $arg_value ? 'true' : 'false';
  832.                 $arg_list[] = "'$arg_name' => $arg_value";
  833.             }
  834.         }
  835.  
  836.         if($this->_reg_objects[$object][2]) {
  837.             // smarty object argument format
  838.             $args = "array(".implode(',', (array)$arg_list)."), \$this";
  839.         } else {
  840.             // traditional argument format
  841.             $args = implode(',', array_values($attrs));
  842.             if (empty($args)) {
  843.                 $args = 'null';
  844.             }
  845.         }
  846.  
  847.         $prefix = '';
  848.         $postfix = '';
  849.         $newline = '';
  850.         if(!is_object($this->_reg_objects[$object][0])) {
  851.             $this->_trigger_fatal_error("registered '$object' is not an object" , $this->_current_file, $this->_current_line_no, __FILE__, __LINE__);
  852.         } elseif(!empty($this->_reg_objects[$object][1]) && !in_array($obj_comp, $this->_reg_objects[$object][1])) {
  853.             $this->_trigger_fatal_error("'$obj_comp' is not a registered component of object '$object'", $this->_current_file, $this->_current_line_no, __FILE__, __LINE__);
  854.         } elseif(method_exists($this->_reg_objects[$object][0], $obj_comp)) {
  855.             // method
  856.             if(in_array($obj_comp, $this->_reg_objects[$object][3])) {
  857.                 // block method
  858.                 if ($start_tag) {
  859.                     $prefix = "\$this->_tag_stack[] = array('$obj_comp', $args); ";
  860.                     $prefix .= "\$this->_reg_objects['$object'][0]->$obj_comp(\$this->_tag_stack[count(\$this->_tag_stack)-1][1], null, \$this, \$_block_repeat=true); ";
  861.                     $prefix .= "while (\$_block_repeat) { ob_start();";
  862.                     $return = null;
  863.                     $postfix = '';
  864.             } else {
  865.                     $prefix = "\$this->_obj_block_content = ob_get_contents(); ob_end_clean(); ";
  866.                     $return = "\$this->_reg_objects['$object'][0]->$obj_comp(\$this->_tag_stack[count(\$this->_tag_stack)-1][1], \$this->_obj_block_content, \$this, \$_block_repeat=false)";
  867.                     $postfix = "} array_pop(\$this->_tag_stack);";
  868.                 }
  869.             } else {
  870.                 // non-block method
  871.                 $return = "\$this->_reg_objects['$object'][0]->$obj_comp($args)";
  872.             }
  873.         } else {
  874.             // property
  875.             $return = "\$this->_reg_objects['$object'][0]->$obj_comp";
  876.         }
  877.  
  878.         if($return != null) {
  879.             if($tag_modifier != '') {
  880.                 $this->_parse_modifiers($return, $tag_modifier);
  881.             }
  882.  
  883.             if(!empty($_assign_var)) {
  884.                 $output = "\$this->assign('" . $this->_dequote($_assign_var) ."',  $return);";
  885.             } else {
  886.                 $output = 'echo ' . $return . ';';
  887.                 $newline = $this->_additional_newline;
  888.             }
  889.         } else {
  890.             $output = '';
  891.         }
  892.  
  893.         return '<?php ' . $prefix . $output . $postfix . "?>" . $newline;
  894.     }
  895.  
  896.     /**
  897.      * Compile {insert ...} tag
  898.      *
  899.      * @param string $tag_args
  900.      * @return string
  901.      */
  902.     function _compile_insert_tag($tag_args)
  903.     {
  904.         $attrs = $this->_parse_attrs($tag_args);
  905.         $name = $this->_dequote($attrs['name']);
  906.  
  907.         if (empty($name)) {
  908.             $this->_syntax_error("missing insert name", E_USER_ERROR, __FILE__, __LINE__);
  909.         }
  910.  
  911.         if (!empty($attrs['script'])) {
  912.             $delayed_loading = true;
  913.         } else {
  914.             $delayed_loading = false;
  915.         }
  916.  
  917.         foreach ($attrs as $arg_name => $arg_value) {
  918.             if (is_bool($arg_value))
  919.                 $arg_value = $arg_value ? 'true' : 'false';
  920.             $arg_list[] = "'$arg_name' => $arg_value";
  921.         }
  922.  
  923.         $this->_add_plugin('insert', $name, $delayed_loading);
  924.  
  925.         $_params = "array('args' => array(".implode(', ', (array)$arg_list)."))";
  926.  
  927.         return "<?php require_once(SMARTY_DIR . 'core' . DIRECTORY_SEPARATOR . 'core.run_insert_handler.php');\necho smarty_core_run_insert_handler($_params, \$this); ?>" . $this->_additional_newline;
  928.     }
  929.  
  930.     /**
  931.      * Compile {include ...} tag
  932.      *
  933.      * @param string $tag_args
  934.      * @return string
  935.      */
  936.     function _compile_include_tag($tag_args)
  937.     {
  938.         $attrs = $this->_parse_attrs($tag_args);
  939.         $arg_list = array();
  940.  
  941.         if (empty($attrs['file'])) {
  942.             $this->_syntax_error("missing 'file' attribute in include tag", E_USER_ERROR, __FILE__, __LINE__);
  943.         }
  944.  
  945.         foreach ($attrs as $arg_name => $arg_value) {
  946.             if ($arg_name == 'file') {
  947.                 $include_file = $arg_value;
  948.                 continue;
  949.             } else if ($arg_name == 'assign') {
  950.                 $assign_var = $arg_value;
  951.                 continue;
  952.             }
  953.             if (is_bool($arg_value))
  954.                 $arg_value = $arg_value ? 'true' : 'false';
  955.             $arg_list[] = "'$arg_name' => $arg_value";
  956.         }
  957.  
  958.         $output = '<?php ';
  959.  
  960.         if (isset($assign_var)) {
  961.             $output .= "ob_start();\n";
  962.         }
  963.  
  964.         $output .=
  965.             "\$_smarty_tpl_vars = \$this->_tpl_vars;\n";
  966.  
  967.  
  968.         $_params = "array('smarty_include_tpl_file' => " . $include_file . ", 'smarty_include_vars' => array(".implode(',', (array)$arg_list)."))";
  969.         $output .= "\$this->_smarty_include($_params);\n" .
  970.         "\$this->_tpl_vars = \$_smarty_tpl_vars;\n" .
  971.         "unset(\$_smarty_tpl_vars);\n";
  972.  
  973.         if (isset($assign_var)) {
  974.             $output .= "\$this->assign(" . $assign_var . ", ob_get_contents()); ob_end_clean();\n";
  975.         }
  976.  
  977.         $output .= ' ?>';
  978.  
  979.         return $output;
  980.  
  981.     }
  982.  
  983.     /**
  984.      * Compile {include ...} tag
  985.      *
  986.      * @param string $tag_args
  987.      * @return string
  988.      */
  989.     function _compile_include_php_tag($tag_args)
  990.     {
  991.         $attrs = $this->_parse_attrs($tag_args);
  992.  
  993.         if (empty($attrs['file'])) {
  994.             $this->_syntax_error("missing 'file' attribute in include_php tag", E_USER_ERROR, __FILE__, __LINE__);
  995.         }
  996.  
  997.         $assign_var = (empty($attrs['assign'])) ? '' : $this->_dequote($attrs['assign']);
  998.         $once_var = (empty($attrs['once']) || $attrs['once']=='false') ? 'false' : 'true';
  999.  
  1000.         $arg_list = array();
  1001.         foreach($attrs as $arg_name => $arg_value) {
  1002.             if($arg_name != 'file' AND $arg_name != 'once' AND $arg_name != 'assign') {
  1003.                 if(is_bool($arg_value))
  1004.                     $arg_value = $arg_value ? 'true' : 'false';
  1005.                 $arg_list[] = "'$arg_name' => $arg_value";
  1006.             }
  1007.         }
  1008.  
  1009.         $_params = "array('smarty_file' => " . $attrs['file'] . ", 'smarty_assign' => '$assign_var', 'smarty_once' => $once_var, 'smarty_include_vars' => array(".implode(',', $arg_list)."))";
  1010.  
  1011.         return "<?php require_once(SMARTY_DIR . 'core' . DIRECTORY_SEPARATOR . 'core.smarty_include_php.php');\nsmarty_core_smarty_include_php($_params, \$this); ?>" . $this->_additional_newline;
  1012.     }
  1013.  
  1014.  
  1015.     /**
  1016.      * Compile {section ...} tag
  1017.      *
  1018.      * @param string $tag_args
  1019.      * @return string
  1020.      */
  1021.     function _compile_section_start($tag_args)
  1022.     {
  1023.         $attrs = $this->_parse_attrs($tag_args);
  1024.         $arg_list = array();
  1025.  
  1026.         $output = '<?php ';
  1027.         $section_name = $attrs['name'];
  1028.         if (empty($section_name)) {
  1029.             $this->_syntax_error("missing section name", E_USER_ERROR, __FILE__, __LINE__);
  1030.         }
  1031.  
  1032.         $output .= "unset(\$this->_sections[$section_name]);\n";
  1033.         $section_props = "\$this->_sections[$section_name]";
  1034.  
  1035.         foreach ($attrs as $attr_name => $attr_value) {
  1036.             switch ($attr_name) {
  1037.                 case 'loop':
  1038.                     $output .= "{$section_props}['loop'] = is_array(\$_loop=$attr_value) ? count(\$_loop) : max(0, (int)\$_loop); unset(\$_loop);\n";
  1039.                     break;
  1040.  
  1041.                 case 'show':
  1042.                     if (is_bool($attr_value))
  1043.                         $show_attr_value = $attr_value ? 'true' : 'false';
  1044.                     else
  1045.                         $show_attr_value = "(bool)$attr_value";
  1046.                     $output .= "{$section_props}['show'] = $show_attr_value;\n";
  1047.                     break;
  1048.  
  1049.                 case 'name':
  1050.                     $output .= "{$section_props}['$attr_name'] = $attr_value;\n";
  1051.                     break;
  1052.  
  1053.                 case 'max':
  1054.                 case 'start':
  1055.                     $output .= "{$section_props}['$attr_name'] = (int)$attr_value;\n";
  1056.                     break;
  1057.  
  1058.                 case 'step':
  1059.                     $output .= "{$section_props}['$attr_name'] = ((int)$attr_value) == 0 ? 1 : (int)$attr_value;\n";
  1060.                     break;
  1061.  
  1062.                 default:
  1063.                     $this->_syntax_error("unknown section attribute - '$attr_name'", E_USER_ERROR, __FILE__, __LINE__);
  1064.                     break;
  1065.             }
  1066.         }
  1067.  
  1068.         if (!isset($attrs['show']))
  1069.             $output .= "{$section_props}['show'] = true;\n";
  1070.  
  1071.         if (!isset($attrs['loop']))
  1072.             $output .= "{$section_props}['loop'] = 1;\n";
  1073.  
  1074.         if (!isset($attrs['max']))
  1075.             $output .= "{$section_props}['max'] = {$section_props}['loop'];\n";
  1076.         else
  1077.             $output .= "if ({$section_props}['max'] < 0)\n" .
  1078.                        "    {$section_props}['max'] = {$section_props}['loop'];\n";
  1079.  
  1080.         if (!isset($attrs['step']))
  1081.             $output .= "{$section_props}['step'] = 1;\n";
  1082.  
  1083.         if (!isset($attrs['start']))
  1084.             $output .= "{$section_props}['start'] = {$section_props}['step'] > 0 ? 0 : {$section_props}['loop']-1;\n";
  1085.         else {
  1086.             $output .= "if ({$section_props}['start'] < 0)\n" .
  1087.                        "    {$section_props}['start'] = max({$section_props}['step'] > 0 ? 0 : -1, {$section_props}['loop'] + {$section_props}['start']);\n" .
  1088.                        "else\n" .
  1089.                        "    {$section_props}['start'] = min({$section_props}['start'], {$section_props}['step'] > 0 ? {$section_props}['loop'] : {$section_props}['loop']-1);\n";
  1090.         }
  1091.  
  1092.         $output .= "if ({$section_props}['show']) {\n";
  1093.         if (!isset($attrs['start']) && !isset($attrs['step']) && !isset($attrs['max'])) {
  1094.             $output .= "    {$section_props}['total'] = {$section_props}['loop'];\n";
  1095.         } else {
  1096.             $output .= "    {$section_props}['total'] = min(ceil(({$section_props}['step'] > 0 ? {$section_props}['loop'] - {$section_props}['start'] : {$section_props}['start']+1)/abs({$section_props}['step'])), {$section_props}['max']);\n";
  1097.         }
  1098.         $output .= "    if ({$section_props}['total'] == 0)\n" .
  1099.                    "        {$section_props}['show'] = false;\n" .
  1100.                    "} else\n" .
  1101.                    "    {$section_props}['total'] = 0;\n";
  1102.  
  1103.         $output .= "if ({$section_props}['show']):\n";
  1104.         $output .= "
  1105.             for ({$section_props}['index'] = {$section_props}['start'], {$section_props}['iteration'] = 1;
  1106.                  {$section_props}['iteration'] <= {$section_props}['total'];
  1107.                  {$section_props}['index'] += {$section_props}['step'], {$section_props}['iteration']++):\n";
  1108.         $output .= "{$section_props}['rownum'] = {$section_props}['iteration'];\n";
  1109.         $output .= "{$section_props}['index_prev'] = {$section_props}['index'] - {$section_props}['step'];\n";
  1110.         $output .= "{$section_props}['index_next'] = {$section_props}['index'] + {$section_props}['step'];\n";
  1111.         $output .= "{$section_props}['first']      = ({$section_props}['iteration'] == 1);\n";
  1112.         $output .= "{$section_props}['last']       = ({$section_props}['iteration'] == {$section_props}['total']);\n";
  1113.  
  1114.         $output .= "?>";
  1115.  
  1116.         return $output;
  1117.     }
  1118.  
  1119.  
  1120.     /**
  1121.      * Compile {foreach ...} tag.
  1122.      *
  1123.      * @param string $tag_args
  1124.      * @return string
  1125.      */
  1126.     function _compile_foreach_start($tag_args)
  1127.     {
  1128.         $attrs = $this->_parse_attrs($tag_args);
  1129.         $arg_list = array();
  1130.  
  1131.         if (empty($attrs['from'])) {
  1132.             return $this->_syntax_error("foreach: missing 'from' attribute", E_USER_ERROR, __FILE__, __LINE__);
  1133.         }
  1134.         $from = $attrs['from'];
  1135.  
  1136.         if (empty($attrs['item'])) {
  1137.             return $this->_syntax_error("foreach: missing 'item' attribute", E_USER_ERROR, __FILE__, __LINE__);
  1138.         }
  1139.         $item = $this->_dequote($attrs['item']);
  1140.         if (!preg_match('~^\w+$~', $item)) {
  1141.             return $this->_syntax_error("'foreach: item' must be a variable name (literal string)", E_USER_ERROR, __FILE__, __LINE__);
  1142.         }
  1143.  
  1144.         if (isset($attrs['key'])) {
  1145.             $key  = $this->_dequote($attrs['key']);
  1146.             if (!preg_match('~^\w+$~', $key)) {
  1147.                 return $this->_syntax_error("foreach: 'key' must to be a variable name (literal string)", E_USER_ERROR, __FILE__, __LINE__);
  1148.             }
  1149.             $key_part = "\$this->_tpl_vars['$key'] => ";
  1150.         } else {
  1151.             $key = null;
  1152.             $key_part = '';
  1153.         }
  1154.  
  1155.         if (isset($attrs['name'])) {
  1156.             $name = $attrs['name'];
  1157.         } else {
  1158.             $name = null;
  1159.         }
  1160.  
  1161.         $output = '<?php ';
  1162.         if (isset($name)) {
  1163.             $foreach_props = "\$this->_foreach[$name]";
  1164.             $output .= "if (isset(\$this->_foreach[$name])) unset(\$this->_foreach[$name]);\n";
  1165.             $output .= "{$foreach_props}['total'] = count(\$_from = (array)$from);\n";
  1166.             $output .= "{$foreach_props}['show'] = {$foreach_props}['total'] > 0;\n";
  1167.             $output .= "if ({$foreach_props}['show']):\n";
  1168.             $output .= "{$foreach_props}['iteration'] = 0;\n";
  1169.             $output .= "    foreach (\$_from as $key_part\$this->_tpl_vars['$item']):\n";
  1170.             $output .= "        {$foreach_props}['iteration']++;\n";
  1171.             $output .= "        {$foreach_props}['first'] = ({$foreach_props}['iteration'] == 1);\n";
  1172.             $output .= "        {$foreach_props}['last']  = ({$foreach_props}['iteration'] == {$foreach_props}['total']);\n";
  1173.         } else {
  1174.             $output .= "if (count(\$_from = (array)$from)):\n";
  1175.             $output .= "    foreach (\$_from as $key_part\$this->_tpl_vars['$item']):\n";
  1176.         }
  1177.         $output .= '?>';
  1178.  
  1179.         return $output;
  1180.     }
  1181.  
  1182.  
  1183.     /**
  1184.      * Compile {capture} .. {/capture} tags
  1185.      *
  1186.      * @param boolean $start true if this is the {capture} tag
  1187.      * @param string $tag_args
  1188.      * @return string
  1189.      */
  1190.  
  1191.     function _compile_capture_tag($start, $tag_args = '')
  1192.     {
  1193.         $attrs = $this->_parse_attrs($tag_args);
  1194.  
  1195.         if ($start) {
  1196.             if (isset($attrs['name']))
  1197.                 $buffer = $attrs['name'];
  1198.             else
  1199.                 $buffer = "'default'";
  1200.  
  1201.             if (isset($attrs['assign']))
  1202.                 $assign = $attrs['assign'];
  1203.             else
  1204.                 $assign = null;
  1205.             $output = "<?php ob_start(); ?>";
  1206.             $this->_capture_stack[] = array($buffer, $assign);
  1207.         } else {
  1208.             list($buffer, $assign) = array_pop($this->_capture_stack);
  1209.             $output = "<?php \$this->_smarty_vars['capture'][$buffer] = ob_get_contents(); ";
  1210.             if (isset($assign)) {
  1211.                 $output .= " \$this->assign($assign, ob_get_contents());";
  1212.             }
  1213.             $output .= "ob_end_clean(); ?>";
  1214.         }
  1215.  
  1216.         return $output;
  1217.     }
  1218.  
  1219.     /**
  1220.      * Compile {if ...} tag
  1221.      *
  1222.      * @param string $tag_args
  1223.      * @param boolean $elseif if true, uses elseif instead of if
  1224.      * @return string
  1225.      */
  1226.     function _compile_if_tag($tag_args, $elseif = false)
  1227.     {
  1228.  
  1229.         /* Tokenize args for 'if' tag. */
  1230.         preg_match_all('~(?>
  1231.                 ' . $this->_obj_call_regexp . '(?:' . $this->_mod_regexp . '*)? | # valid object call
  1232.                 ' . $this->_var_regexp . '(?:' . $this->_mod_regexp . '*)?    | # var or quoted string
  1233.                 \-?0[xX][0-9a-fA-F]+|\-?\d+(?:\.\d+)?|\.\d+|!==|===|==|!=|<>|<<|>>|<=|>=|\&\&|\|\||\(|\)|,|\!|\^|=|\&|\~|<|>|\||\%|\+|\-|\/|\*|\@    | # valid non-word token
  1234.                 \b\w+\b                                                        | # valid word token
  1235.                 \S+                                                           # anything else
  1236.                 )~x', $tag_args, $match);
  1237.  
  1238.         $tokens = $match[0];
  1239.  
  1240.         // make sure we have balanced parenthesis
  1241.         $token_count = array_count_values($tokens);
  1242.         if(isset($token_count['(']) && $token_count['('] != $token_count[')']) {
  1243.             $this->_syntax_error("unbalanced parenthesis in if statement", E_USER_ERROR, __FILE__, __LINE__);
  1244.         }
  1245.  
  1246.         $is_arg_stack = array();
  1247.  
  1248.         for ($i = 0; $i < count($tokens); $i++) {
  1249.  
  1250.             $token = &$tokens[$i];
  1251.  
  1252.             switch (strtolower($token)) {
  1253.                 case '!':
  1254.                 case '%':
  1255.                 case '!==':
  1256.                 case '==':
  1257.                 case '===':
  1258.                 case '>':
  1259.                 case '<':
  1260.                 case '!=':
  1261.                 case '<>':
  1262.                 case '<<':
  1263.                 case '>>':
  1264.                 case '<=':
  1265.                 case '>=':
  1266.                 case '&&':
  1267.                 case '||':
  1268.                 case '|':
  1269.                 case '^':
  1270.                 case '&':
  1271.                 case '~':
  1272.                 case ')':
  1273.                 case ',':
  1274.                 case '+':
  1275.                 case '-':
  1276.                 case '*':
  1277.                 case '/':
  1278.                 case '@':
  1279.                     break;
  1280.  
  1281.                 case 'eq':
  1282.                     $token = '==';
  1283.                     break;
  1284.  
  1285.                 case 'ne':
  1286.                 case 'neq':
  1287.                     $token = '!=';
  1288.                     break;
  1289.  
  1290.                 case 'lt':
  1291.                     $token = '<';
  1292.                     break;
  1293.  
  1294.                 case 'le':
  1295.                 case 'lte':
  1296.                     $token = '<=';
  1297.                     break;
  1298.  
  1299.                 case 'gt':
  1300.                     $token = '>';
  1301.                     break;
  1302.  
  1303.                 case 'ge':
  1304.                 case 'gte':
  1305.                     $token = '>=';
  1306.                     break;
  1307.  
  1308.                 case 'and':
  1309.                     $token = '&&';
  1310.                     break;
  1311.  
  1312.                 case 'or':
  1313.                     $token = '||';
  1314.                     break;
  1315.  
  1316.                 case 'not':
  1317.                     $token = '!';
  1318.                     break;
  1319.  
  1320.                 case 'mod':
  1321.                     $token = '%';
  1322.                     break;
  1323.  
  1324.                 case '(':
  1325.                     array_push($is_arg_stack, $i);
  1326.                     break;
  1327.  
  1328.                 case 'is':
  1329.                     /* If last token was a ')', we operate on the parenthesized
  1330.                        expression. The start of the expression is on the stack.
  1331.                        Otherwise, we operate on the last encountered token. */
  1332.                     if ($tokens[$i-1] == ')')
  1333.                         $is_arg_start = array_pop($is_arg_stack);
  1334.                     else
  1335.                         $is_arg_start = $i-1;
  1336.                     /* Construct the argument for 'is' expression, so it knows
  1337.                        what to operate on. */
  1338.                     $is_arg = implode(' ', array_slice($tokens, $is_arg_start, $i - $is_arg_start));
  1339.  
  1340.                     /* Pass all tokens from next one until the end to the
  1341.                        'is' expression parsing function. The function will
  1342.                        return modified tokens, where the first one is the result
  1343.                        of the 'is' expression and the rest are the tokens it
  1344.                        didn't touch. */
  1345.                     $new_tokens = $this->_parse_is_expr($is_arg, array_slice($tokens, $i+1));
  1346.  
  1347.                     /* Replace the old tokens with the new ones. */
  1348.                     array_splice($tokens, $is_arg_start, count($tokens), $new_tokens);
  1349.  
  1350.                     /* Adjust argument start so that it won't change from the
  1351.                        current position for the next iteration. */
  1352.                     $i = $is_arg_start;
  1353.                     break;
  1354.  
  1355.                 default:
  1356.                     if(preg_match('~^' . $this->_func_regexp . '$~', $token) ) {
  1357.                             // function call
  1358.                             if($this->security &&
  1359.                                !in_array($token, $this->security_settings['IF_FUNCS'])) {
  1360.                                 $this->_syntax_error("(secure mode) '$token' not allowed in if statement", E_USER_ERROR, __FILE__, __LINE__);
  1361.                             }
  1362.                     } elseif(preg_match('~^' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '(?:' . $this->_mod_regexp . '*)$~', $token)) {
  1363.                         // object or variable
  1364.                         $token = $this->_parse_var_props($token);
  1365.                     } elseif(is_numeric($token)) {
  1366.                         // number, skip it
  1367.                     } else {
  1368.                         $this->_syntax_error("unidentified token '$token'", E_USER_ERROR, __FILE__, __LINE__);
  1369.                     }
  1370.                     break;
  1371.             }
  1372.         }
  1373.  
  1374.         if ($elseif)
  1375.             return '<?php elseif ('.implode(' ', $tokens).'): ?>';
  1376.         else
  1377.             return '<?php if ('.implode(' ', $tokens).'): ?>';
  1378.     }
  1379.  
  1380.  
  1381.     function _compile_arg_list($type, $name, $attrs, &$cache_code) {
  1382.         $arg_list = array();
  1383.  
  1384.         if (isset($type) && isset($name)
  1385.             && isset($this->_plugins[$type])
  1386.             && isset($this->_plugins[$type][$name])
  1387.             && empty($this->_plugins[$type][$name][4])
  1388.             && is_array($this->_plugins[$type][$name][5])
  1389.             ) {
  1390.             /* we have a list of parameters that should be cached */
  1391.             $_cache_attrs = $this->_plugins[$type][$name][5];
  1392.             $_count = $this->_cache_attrs_count++;
  1393.             $cache_code = "\$_cache_attrs =& \$this->_smarty_cache_attrs('$this->_cache_serial','$_count');";
  1394.  
  1395.         } else {
  1396.             /* no parameters are cached */
  1397.             $_cache_attrs = null;
  1398.         }
  1399.  
  1400.         foreach ($attrs as $arg_name => $arg_value) {
  1401.             if (is_bool($arg_value))
  1402.                 $arg_value = $arg_value ? 'true' : 'false';
  1403.             if (is_null($arg_value))
  1404.                 $arg_value = 'null';
  1405.             if ($_cache_attrs && in_array($arg_name, $_cache_attrs)) {
  1406.                 $arg_list[] = "'$arg_name' => (\$this->_cache_including) ? \$_cache_attrs['$arg_name'] : (\$_cache_attrs['$arg_name']=$arg_value)";
  1407.             } else {
  1408.                 $arg_list[] = "'$arg_name' => $arg_value";
  1409.             }
  1410.         }
  1411.         return $arg_list;
  1412.     }
  1413.  
  1414.     /**
  1415.      * Parse is expression
  1416.      *
  1417.      * @param string $is_arg
  1418.      * @param array $tokens
  1419.      * @return array
  1420.      */
  1421.     function _parse_is_expr($is_arg, $tokens)
  1422.     {
  1423.         $expr_end = 0;
  1424.         $negate_expr = false;
  1425.  
  1426.         if (($first_token = array_shift($tokens)) == 'not') {
  1427.             $negate_expr = true;
  1428.             $expr_type = array_shift($tokens);
  1429.         } else
  1430.             $expr_type = $first_token;
  1431.  
  1432.         switch ($expr_type) {
  1433.             case 'even':
  1434.                 if (isset($tokens[$expr_end]) && $tokens[$expr_end] == 'by') {
  1435.                     $expr_end++;
  1436.                     $expr_arg = $tokens[$expr_end++];
  1437.                     $expr = "!(1 & ($is_arg / " . $this->_parse_var_props($expr_arg) . "))";
  1438.                 } else
  1439.                     $expr = "!(1 & $is_arg)";
  1440.                 break;
  1441.  
  1442.             case 'odd':
  1443.                 if (isset($tokens[$expr_end]) && $tokens[$expr_end] == 'by') {
  1444.                     $expr_end++;
  1445.                     $expr_arg = $tokens[$expr_end++];
  1446.                     $expr = "(1 & ($is_arg / " . $this->_parse_var_props($expr_arg) . "))";
  1447.                 } else
  1448.                     $expr = "(1 & $is_arg)";
  1449.                 break;
  1450.  
  1451.             case 'div':
  1452.                 if (@$tokens[$expr_end] == 'by') {
  1453.                     $expr_end++;
  1454.                     $expr_arg = $tokens[$expr_end++];
  1455.                     $expr = "!($is_arg % " . $this->_parse_var_props($expr_arg) . ")";
  1456.                 } else {
  1457.                     $this->_syntax_error("expecting 'by' after 'div'", E_USER_ERROR, __FILE__, __LINE__);
  1458.                 }
  1459.                 break;
  1460.  
  1461.             default:
  1462.                 $this->_syntax_error("unknown 'is' expression - '$expr_type'", E_USER_ERROR, __FILE__, __LINE__);
  1463.                 break;
  1464.         }
  1465.  
  1466.         if ($negate_expr) {
  1467.             $expr = "!($expr)";
  1468.         }
  1469.  
  1470.         array_splice($tokens, 0, $expr_end, $expr);
  1471.  
  1472.         return $tokens;
  1473.     }
  1474.  
  1475.  
  1476.     /**
  1477.      * Parse attribute string
  1478.      *
  1479.      * @param string $tag_args
  1480.      * @return array
  1481.      */
  1482.     function _parse_attrs($tag_args)
  1483.     {
  1484.  
  1485.         /* Tokenize tag attributes. */
  1486.         preg_match_all('~(?:' . $this->_obj_call_regexp . '|' . $this->_qstr_regexp . ' | (?>[^"\'=\s]+)
  1487.                          )+ |
  1488.                          [=]
  1489.                         ~x', $tag_args, $match);
  1490.         $tokens       = $match[0];
  1491.  
  1492.         $attrs = array();
  1493.         /* Parse state:
  1494.             0 - expecting attribute name
  1495.             1 - expecting '='
  1496.             2 - expecting attribute value (not '=') */
  1497.         $state = 0;
  1498.  
  1499.         foreach ($tokens as $token) {
  1500.             switch ($state) {
  1501.                 case 0:
  1502.                     /* If the token is a valid identifier, we set attribute name
  1503.                        and go to state 1. */
  1504.                     if (preg_match('~^\w+$~', $token)) {
  1505.                         $attr_name = $token;
  1506.                         $state = 1;
  1507.                     } else
  1508.                         $this->_syntax_error("invalid attribute name: '$token'", E_USER_ERROR, __FILE__, __LINE__);
  1509.                     break;
  1510.  
  1511.                 case 1:
  1512.                     /* If the token is '=', then we go to state 2. */
  1513.                     if ($token == '=') {
  1514.                         $state = 2;
  1515.                     } else
  1516.                         $this->_syntax_error("expecting '=' after attribute name '$last_token'", E_USER_ERROR, __FILE__, __LINE__);
  1517.                     break;
  1518.  
  1519.                 case 2:
  1520.                     /* If token is not '=', we set the attribute value and go to
  1521.                        state 0. */
  1522.                     if ($token != '=') {
  1523.                         /* We booleanize the token if it's a non-quoted possible
  1524.                            boolean value. */
  1525.                         if (preg_match('~^(on|yes|true)$~', $token)) {
  1526.                             $token = 'true';
  1527.                         } else if (preg_match('~^(off|no|false)$~', $token)) {
  1528.                             $token = 'false';
  1529.                         } else if ($token == 'null') {
  1530.                             $token = 'null';
  1531.                         } else if (preg_match('~^-?([0-9]+|0[xX][0-9a-fA-F]+)$~', $token)) {
  1532.                             /* treat integer literally */
  1533.                         } else if (!preg_match('~^' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '(?:' . $this->_mod_regexp . ')*$~', $token)) {
  1534.                             /* treat as a string, double-quote it escaping quotes */
  1535.                             $token = '"'.addslashes($token).'"';
  1536.                         }
  1537.  
  1538.                         $attrs[$attr_name] = $token;
  1539.                         $state = 0;
  1540.                     } else
  1541.                         $this->_syntax_error("'=' cannot be an attribute value", E_USER_ERROR, __FILE__, __LINE__);
  1542.                     break;
  1543.             }
  1544.             $last_token = $token;
  1545.         }
  1546.  
  1547.         if($state != 0) {
  1548.             if($state == 1) {
  1549.                 $this->_syntax_error("expecting '=' after attribute name '$last_token'", E_USER_ERROR, __FILE__, __LINE__);
  1550.             } else {
  1551.                 $this->_syntax_error("missing attribute value", E_USER_ERROR, __FILE__, __LINE__);
  1552.             }
  1553.         }
  1554.  
  1555.         $this->_parse_vars_props($attrs);
  1556.  
  1557.         return $attrs;
  1558.     }
  1559.  
  1560.     /**
  1561.      * compile multiple variables and section properties tokens into
  1562.      * PHP code
  1563.      *
  1564.      * @param array $tokens
  1565.      */
  1566.     function _parse_vars_props(&$tokens)
  1567.     {
  1568.         foreach($tokens as $key => $val) {
  1569.             $tokens[$key] = $this->_parse_var_props($val);
  1570.         }
  1571.     }
  1572.  
  1573.     /**
  1574.      * compile single variable and section properties token into
  1575.      * PHP code
  1576.      *
  1577.      * @param string $val
  1578.      * @param string $tag_attrs
  1579.      * @return string
  1580.      */
  1581.     function _parse_var_props($val)
  1582.     {
  1583.         $val = trim($val);
  1584.  
  1585.         if(preg_match('~^(' . $this->_obj_call_regexp . '|' . $this->_dvar_regexp . ')(' . $this->_mod_regexp . '*)$~', $val, $match)) {
  1586.             // $ variable or object
  1587.             $return = $this->_parse_var($match[1]);
  1588.             $modifiers = $match[2];
  1589.             if (!empty($this->default_modifiers) && !preg_match('~(^|\|)smarty:nodefaults($|\|)~',$modifiers)) {
  1590.                 $_default_mod_string = implode('|',(array)$this->default_modifiers);
  1591.                 $modifiers = empty($modifiers) ? $_default_mod_string : $_default_mod_string . '|' . $modifiers;
  1592.             }
  1593.             $this->_parse_modifiers($return, $modifiers);
  1594.             return $return;
  1595.         } elseif (preg_match('~^' . $this->_db_qstr_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
  1596.                 // double quoted text
  1597.                 preg_match('~^(' . $this->_db_qstr_regexp . ')('. $this->_mod_regexp . '*)$~', $val, $match);
  1598.                 $return = $this->_expand_quoted_text($match[1]);
  1599.                 if($match[2] != '') {
  1600.                     $this->_parse_modifiers($return, $match[2]);
  1601.                 }
  1602.                 return $return;
  1603.             }
  1604.         elseif(preg_match('~^' . $this->_num_const_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
  1605.                 // numerical constant
  1606.                 preg_match('~^(' . $this->_num_const_regexp . ')('. $this->_mod_regexp . '*)$~', $val, $match);
  1607.                 if($match[2] != '') {
  1608.                     $this->_parse_modifiers($match[1], $match[2]);
  1609.                     return $match[1];
  1610.                 }
  1611.             }
  1612.         elseif(preg_match('~^' . $this->_si_qstr_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
  1613.                 // single quoted text
  1614.                 preg_match('~^(' . $this->_si_qstr_regexp . ')('. $this->_mod_regexp . '*)$~', $val, $match);
  1615.                 if($match[2] != '') {
  1616.                     $this->_parse_modifiers($match[1], $match[2]);
  1617.                     return $match[1];
  1618.                 }
  1619.             }
  1620.         elseif(preg_match('~^' . $this->_cvar_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
  1621.                 // config var
  1622.                 return $this->_parse_conf_var($val);
  1623.             }
  1624.         elseif(preg_match('~^' . $this->_svar_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
  1625.                 // section var
  1626.                 return $this->_parse_section_prop($val);
  1627.             }
  1628.         elseif(!in_array($val, $this->_permitted_tokens) && !is_numeric($val)) {
  1629.             // literal string
  1630.             return $this->_expand_quoted_text('"' . $val .'"');
  1631.         }
  1632.         return $val;
  1633.     }
  1634.  
  1635.     /**
  1636.      * expand quoted text with embedded variables
  1637.      *
  1638.      * @param string $var_expr
  1639.      * @return string
  1640.      */
  1641.     function _expand_quoted_text($var_expr)
  1642.     {
  1643.         // if contains unescaped $, expand it
  1644.         if(preg_match_all('~(?:\`(?<!\\\\)\$' . $this->_dvar_guts_regexp . '\`)|(?:(?<!\\\\)\$\w+(\[[a-zA-Z0-9]+\])*)~', $var_expr, $_match)) {
  1645.             $_match = $_match[0];
  1646.             rsort($_match);
  1647.             reset($_match);
  1648.             foreach($_match as $_var) {
  1649.                 $var_expr = str_replace ($_var, '".(' . $this->_parse_var(str_replace('`','',$_var)) . ')."', $var_expr);
  1650.             }
  1651.             $_return = preg_replace('~\.""|(?<!\\\\)""\.~', '', $var_expr);
  1652.         } else {
  1653.             $_return = $var_expr;
  1654.         }
  1655.         // replace double quoted literal string with single quotes
  1656.         $_return = preg_replace('~^"([\s\w]+)"$~',"'\\1'",$_return);
  1657.         return $_return;
  1658.     }
  1659.  
  1660.     /**
  1661.      * parse variable expression into PHP code
  1662.      *
  1663.      * @param string $var_expr
  1664.      * @param string $output
  1665.      * @return string
  1666.      */
  1667.     function _parse_var($var_expr)
  1668.     {
  1669.         $_has_math = false;
  1670.         $_math_vars = preg_split('~('.$this->_dvar_math_regexp.'|'.$this->_qstr_regexp.')~', $var_expr, -1, PREG_SPLIT_DELIM_CAPTURE);
  1671.  
  1672.         if(count($_math_vars) > 1) {
  1673.             $_first_var = "";
  1674.             $_complete_var = "";
  1675.             $_output = "";
  1676.             // simple check if there is any math, to stop recursion (due to modifiers with "xx % yy" as parameter)
  1677.             foreach($_math_vars as $_k => $_math_var) {
  1678.                 $_math_var = $_math_vars[$_k];
  1679.  
  1680.                 if(!empty($_math_var) || is_numeric($_math_var)) {
  1681.                     // hit a math operator, so process the stuff which came before it
  1682.                     if(preg_match('~^' . $this->_dvar_math_regexp . '$~', $_math_var)) {
  1683.                         $_has_math = true;
  1684.                         if(!empty($_complete_var) || is_numeric($_complete_var)) {
  1685.                             $_output .= $this->_parse_var($_complete_var);
  1686.                         }
  1687.  
  1688.                         // just output the math operator to php
  1689.                         $_output .= $_math_var;
  1690.  
  1691.                         if(empty($_first_var))
  1692.                             $_first_var = $_complete_var;
  1693.  
  1694.                         $_complete_var = "";
  1695.                     } else {
  1696.                         $_complete_var .= $_math_var;
  1697.                     }
  1698.                 }
  1699.             }
  1700.             if($_has_math) {
  1701.                 if(!empty($_complete_var) || is_numeric($_complete_var))
  1702.                     $_output .= $this->_parse_var($_complete_var);
  1703.  
  1704.                 // get the modifiers working (only the last var from math + modifier is left)
  1705.                 $var_expr = $_complete_var;
  1706.             }
  1707.         }
  1708.  
  1709.         // prevent cutting of first digit in the number (we _definitly_ got a number if the first char is a digit)
  1710.         if(is_numeric($var_expr{0}))
  1711.             $_var_ref = $var_expr;
  1712.         else
  1713.             $_var_ref = substr($var_expr, 1);
  1714.         
  1715.         if(!$_has_math) {
  1716.             
  1717.             // get [foo] and .foo and ->foo and (...) pieces
  1718.             preg_match_all('~(?:^\w+)|' . $this->_obj_params_regexp . '|(?:' . $this->_var_bracket_regexp . ')|->\$?\w+|\.\$?\w+|\S+~', $_var_ref, $match);
  1719.                         
  1720.             $_indexes = $match[0];
  1721.             $_var_name = array_shift($_indexes);
  1722.  
  1723.             /* Handle $smarty.* variable references as a special case. */
  1724.             if ($_var_name == 'smarty') {
  1725.                 /*
  1726.                  * If the reference could be compiled, use the compiled output;
  1727.                  * otherwise, fall back on the $smarty variable generated at
  1728.                  * run-time.
  1729.                  */
  1730.                 if (($smarty_ref = $this->_compile_smarty_ref($_indexes)) !== null) {
  1731.                     $_output = $smarty_ref;
  1732.                 } else {
  1733.                     $_var_name = substr(array_shift($_indexes), 1);
  1734.                     $_output = "\$this->_smarty_vars['$_var_name']";
  1735.                 }
  1736.             } elseif(is_numeric($_var_name) && is_numeric($var_expr{0})) {
  1737.                 // because . is the operator for accessing arrays thru inidizes we need to put it together again for floating point numbers
  1738.                 if(count($_indexes) > 0)
  1739.                 {
  1740.                     $_var_name .= implode("", $_indexes);
  1741.                     $_indexes = array();
  1742.                 }
  1743.                 $_output = $_var_name;
  1744.             } else {
  1745.                 $_output = "\$this->_tpl_vars['$_var_name']";
  1746.             }
  1747.  
  1748.             foreach ($_indexes as $_index) {
  1749.                 if ($_index{0} == '[') {
  1750.                     $_index = substr($_index, 1, -1);
  1751.                     if (is_numeric($_index)) {
  1752.                         $_output .= "[$_index]";
  1753.                     } elseif ($_index{0} == '$') {
  1754.                         if (strpos($_index, '.') !== false) {
  1755.                             $_output .= '[' . $this->_parse_var($_index) . ']';
  1756.                         } else {
  1757.                             $_output .= "[\$this->_tpl_vars['" . substr($_index, 1) . "']]";
  1758.                         }
  1759.                     } else {
  1760.                         $_var_parts = explode('.', $_index);
  1761.                         $_var_section = $_var_parts[0];
  1762.                         $_var_section_prop = isset($_var_parts[1]) ? $_var_parts[1] : 'index';
  1763.                         $_output .= "[\$this->_sections['$_var_section']['$_var_section_prop']]";
  1764.                     }
  1765.                 } else if ($_index{0} == '.') {
  1766.                     if ($_index{1} == '$')
  1767.                         $_output .= "[\$this->_tpl_vars['" . substr($_index, 2) . "']]";
  1768.                     else
  1769.                         $_output .= "['" . substr($_index, 1) . "']";
  1770.                 } else if (substr($_index,0,2) == '->') {
  1771.                     if(substr($_index,2,2) == '__') {
  1772.                         $this->_syntax_error('call to internal object members is not allowed', E_USER_ERROR, __FILE__, __LINE__);
  1773.                     } elseif($this->security && substr($_index, 2, 1) == '_') {
  1774.                         $this->_syntax_error('(secure) call to private object member is not allowed', E_USER_ERROR, __FILE__, __LINE__);
  1775.                     } elseif ($_index{2} == '$') {
  1776.                         if ($this->security) {
  1777.                             $this->_syntax_error('(secure) call to dynamic object member is not allowed', E_USER_ERROR, __FILE__, __LINE__);
  1778.                         } else {
  1779.                             $_output .= '->{(($_var=$this->_tpl_vars[\''.substr($_index,3).'\']) && substr($_var,0,2)!=\'__\') ? $_var : $this->trigger_error("cannot access property \\"$_var\\"")}';
  1780.                         }
  1781.                     } else {
  1782.                         $_output .= $_index;
  1783.                     }
  1784.                 } elseif ($_index{0} == '(') {
  1785.                     $_index = $this->_parse_parenth_args($_index);
  1786.                     $_output .= $_index;
  1787.                 } else {
  1788.                     $_output .= $_index;
  1789.                 }
  1790.             }
  1791.         }
  1792.  
  1793.         return $_output;
  1794.     }
  1795.  
  1796.     /**
  1797.      * parse arguments in function call parenthesis
  1798.      *
  1799.      * @param string $parenth_args
  1800.      * @return string
  1801.      */
  1802.     function _parse_parenth_args($parenth_args)
  1803.     {
  1804.         preg_match_all('~' . $this->_param_regexp . '~',$parenth_args, $match);
  1805.         $orig_vals = $match = $match[0];
  1806.         $this->_parse_vars_props($match);
  1807.         $replace = array();
  1808.         for ($i = 0, $count = count($match); $i < $count; $i++) {
  1809.             $replace[$orig_vals[$i]] = $match[$i];
  1810.         }
  1811.         return strtr($parenth_args, $replace);
  1812.     }
  1813.  
  1814.     /**
  1815.      * parse configuration variable expression into PHP code
  1816.      *
  1817.      * @param string $conf_var_expr
  1818.      */
  1819.     function _parse_conf_var($conf_var_expr)
  1820.     {
  1821.         $parts = explode('|', $conf_var_expr, 2);
  1822.         $var_ref = $parts[0];
  1823.         $modifiers = isset($parts[1]) ? $parts[1] : '';
  1824.  
  1825.         $var_name = substr($var_ref, 1, -1);
  1826.  
  1827.         $output = "\$this->_config[0]['vars']['$var_name']";
  1828.  
  1829.         $this->_parse_modifiers($output, $modifiers);
  1830.  
  1831.         return $output;
  1832.     }
  1833.  
  1834.     /**
  1835.      * parse section property expression into PHP code
  1836.      *
  1837.      * @param string $section_prop_expr
  1838.      * @return string
  1839.      */
  1840.     function _parse_section_prop($section_prop_expr)
  1841.     {
  1842.         $parts = explode('|', $section_prop_expr, 2);
  1843.         $var_ref = $parts[0];
  1844.         $modifiers = isset($parts[1]) ? $parts[1] : '';
  1845.  
  1846.         preg_match('!%(\w+)\.(\w+)%!', $var_ref, $match);
  1847.         $section_name = $match[1];
  1848.         $prop_name = $match[2];
  1849.  
  1850.         $output = "\$this->_sections['$section_name']['$prop_name']";
  1851.  
  1852.         $this->_parse_modifiers($output, $modifiers);
  1853.  
  1854.         return $output;
  1855.     }
  1856.  
  1857.  
  1858.     /**
  1859.      * parse modifier chain into PHP code
  1860.      *
  1861.      * sets $output to parsed modified chain
  1862.      * @param string $output
  1863.      * @param string $modifier_string
  1864.      */
  1865.     function _parse_modifiers(&$output, $modifier_string)
  1866.     {
  1867.         preg_match_all('~\|(@?\w+)((?>:(?:'. $this->_qstr_regexp . '|[^|]+))*)~', '|' . $modifier_string, $_match);
  1868.         list(, $_modifiers, $modifier_arg_strings) = $_match;
  1869.  
  1870.         for ($_i = 0, $_for_max = count($_modifiers); $_i < $_for_max; $_i++) {
  1871.             $_modifier_name = $_modifiers[$_i];
  1872.  
  1873.             if($_modifier_name == 'smarty') {
  1874.                 // skip smarty modifier
  1875.                 continue;
  1876.             }
  1877.  
  1878.             preg_match_all('~:(' . $this->_qstr_regexp . '|[^:]+)~', $modifier_arg_strings[$_i], $_match);
  1879.             $_modifier_args = $_match[1];
  1880.  
  1881.             if ($_modifier_name{0} == '@') {
  1882.                 $_map_array = false;
  1883.                 $_modifier_name = substr($_modifier_name, 1);
  1884.             } else {
  1885.                 $_map_array = true;
  1886.             }
  1887.  
  1888.             if (empty($this->_plugins['modifier'][$_modifier_name])
  1889.                 && !$this->_get_plugin_filepath('modifier', $_modifier_name)
  1890.                 && function_exists($_modifier_name)) {
  1891.                 if ($this->security && !in_array($_modifier_name, $this->security_settings['MODIFIER_FUNCS'])) {
  1892.                     $this->_trigger_fatal_error("[plugin] (secure mode) modifier '$_modifier_name' is not allowed" , $this->_current_file, $this->_current_line_no, __FILE__, __LINE__);
  1893.                 } else {
  1894.                     $this->_plugins['modifier'][$_modifier_name] = array($_modifier_name,  null, null, false);
  1895.                 }
  1896.             }
  1897.             $this->_add_plugin('modifier', $_modifier_name);
  1898.  
  1899.             $this->_parse_vars_props($_modifier_args);
  1900.  
  1901.             if($_modifier_name == 'default') {
  1902.                 // supress notifications of default modifier vars and args
  1903.                 if($output{0} == '$') {
  1904.                     $output = '@' . $output;
  1905.                 }
  1906.                 if(isset($_modifier_args[0]) && $_modifier_args[0]{0} == '$') {
  1907.                     $_modifier_args[0] = '@' . $_modifier_args[0];
  1908.                 }
  1909.             }
  1910.             if (count($_modifier_args) > 0)
  1911.                 $_modifier_args = ', '.implode(', ', $_modifier_args);
  1912.             else
  1913.                 $_modifier_args = '';
  1914.  
  1915.             if ($_map_array) {
  1916.                 $output = "((is_array(\$_tmp=$output)) ? \$this->_run_mod_handler('$_modifier_name', true, \$_tmp$_modifier_args) : " . $this->_compile_plugin_call('modifier', $_modifier_name) . "(\$_tmp$_modifier_args))";
  1917.  
  1918.             } else {
  1919.  
  1920.                 $output = $this->_compile_plugin_call('modifier', $_modifier_name)."($output$_modifier_args)";
  1921.  
  1922.             }
  1923.         }
  1924.     }
  1925.  
  1926.  
  1927.     /**
  1928.      * add plugin
  1929.      *
  1930.      * @param string $type
  1931.      * @param string $name
  1932.      * @param boolean? $delayed_loading
  1933.      */
  1934.     function _add_plugin($type, $name, $delayed_loading = null)
  1935.     {
  1936.         if (!isset($this->_plugin_info[$type])) {
  1937.             $this->_plugin_info[$type] = array();
  1938.         }
  1939.         if (!isset($this->_plugin_info[$type][$name])) {
  1940.             $this->_plugin_info[$type][$name] = array($this->_current_file,
  1941.                                                       $this->_current_line_no,
  1942.                                                       $delayed_loading);
  1943.         }
  1944.     }
  1945.  
  1946.  
  1947.     /**
  1948.      * Compiles references of type $smarty.foo
  1949.      *
  1950.      * @param string $indexes
  1951.      * @return string
  1952.      */
  1953.     function _compile_smarty_ref(&$indexes)
  1954.     {
  1955.         /* Extract the reference name. */
  1956.         $_ref = substr($indexes[0], 1);
  1957.         foreach($indexes as $_index_no=>$_index) {
  1958.             if ($_index{0} != '.' && $_index_no<2 || !preg_match('~^(\.|\[|->)~', $_index)) {
  1959.                 $this->_syntax_error('$smarty' . implode('', array_slice($indexes, 0, 2)) . ' is an invalid reference', E_USER_ERROR, __FILE__, __LINE__);
  1960.             }
  1961.         }
  1962.  
  1963.         switch ($_ref) {
  1964.             case 'now':
  1965.                 $compiled_ref = 'time()';
  1966.                 $_max_index = 1;
  1967.                 break;
  1968.  
  1969.             case 'foreach':
  1970.             case 'section':
  1971.                 array_shift($indexes);
  1972.                 $_var = $this->_parse_var_props(substr($indexes[0], 1));
  1973.                 if ($_ref == 'foreach')
  1974.                     $compiled_ref = "\$this->_foreach[$_var]";
  1975.                 else
  1976.                     $compiled_ref = "\$this->_sections[$_var]";
  1977.                 break;
  1978.  
  1979.             case 'get':
  1980.                 $compiled_ref = ($this->request_use_auto_globals) ? '$_GET' : "\$GLOBALS['HTTP_GET_VARS']";
  1981.                 break;
  1982.  
  1983.             case 'post':
  1984.                 $compiled_ref = ($this->request_use_auto_globals) ? '$_POST' : "\$GLOBALS['HTTP_POST_VARS']";
  1985.                 break;
  1986.  
  1987.             case 'cookies':
  1988.                 $compiled_ref = ($this->request_use_auto_globals) ? '$_COOKIE' : "\$GLOBALS['HTTP_COOKIE_VARS']";
  1989.                 break;
  1990.  
  1991.             case 'env':
  1992.                 $compiled_ref = ($this->request_use_auto_globals) ? '$_ENV' : "\$GLOBALS['HTTP_ENV_VARS']";
  1993.                 break;
  1994.  
  1995.             case 'server':
  1996.                 $compiled_ref = ($this->request_use_auto_globals) ? '$_SERVER' : "\$GLOBALS['HTTP_SERVER_VARS']";
  1997.                 break;
  1998.  
  1999.             case 'session':
  2000.                 $compiled_ref = ($this->request_use_auto_globals) ? '$_SESSION' : "\$GLOBALS['HTTP_SESSION_VARS']";
  2001.                 break;
  2002.  
  2003.             /*
  2004.              * These cases are handled either at run-time or elsewhere in the
  2005.              * compiler.
  2006.              */
  2007.             case 'request':
  2008.                 if ($this->request_use_auto_globals) {
  2009.                     $compiled_ref = '$_REQUEST';
  2010.                     break;
  2011.                 } else {
  2012.                     $this->_init_smarty_vars = true;
  2013.                 }
  2014.                 return null;
  2015.  
  2016.             case 'capture':
  2017.                 return null;
  2018.  
  2019.             case 'template':
  2020.                 $compiled_ref = "'$this->_current_file'";
  2021.                 $_max_index = 1;
  2022.                 break;
  2023.  
  2024.             case 'version':
  2025.                 $compiled_ref = "'$this->_version'";
  2026.                 $_max_index = 1;
  2027.                 break;
  2028.  
  2029.             case 'const':
  2030.                 if ($this->security && !$this->security_settings['ALLOW_CONSTANTS']) {
  2031.                     $this->_syntax_error("(secure mode) constants not permitted",
  2032.                                          E_USER_WARNING, __FILE__, __LINE__);
  2033.                     return;
  2034.                 }
  2035.                 array_shift($indexes);
  2036.                 $_val = $this->_parse_var_props(substr($indexes[0],1));
  2037.                 $compiled_ref = '@constant(' . $_val . ')';
  2038.                 $_max_index = 1;
  2039.                 break;
  2040.  
  2041.             case 'config':
  2042.                 $compiled_ref = "\$this->_config[0]['vars']";
  2043.                 $_max_index = 3;
  2044.                 break;
  2045.  
  2046.             case 'ldelim':
  2047.                 $compiled_ref = "'$this->left_delimiter'";
  2048.                 break;
  2049.  
  2050.             case 'rdelim':
  2051.                 $compiled_ref = "'$this->right_delimiter'";
  2052.                 break;
  2053.                 
  2054.             default:
  2055.                 $this->_syntax_error('$smarty.' . $_ref . ' is an unknown reference', E_USER_ERROR, __FILE__, __LINE__);
  2056.                 break;
  2057.         }
  2058.  
  2059.         if (isset($_max_index) && count($indexes) > $_max_index) {
  2060.             $this->_syntax_error('$smarty' . implode('', $indexes) .' is an invalid reference', E_USER_ERROR, __FILE__, __LINE__);
  2061.         }
  2062.  
  2063.         array_shift($indexes);
  2064.         return $compiled_ref;
  2065.     }
  2066.  
  2067.     /**
  2068.      * compiles call to plugin of type $type with name $name
  2069.      * returns a string containing the function-name or method call
  2070.      * without the paramter-list that would have follow to make the
  2071.      * call valid php-syntax
  2072.      *
  2073.      * @param string $type
  2074.      * @param string $name
  2075.      * @return string
  2076.      */
  2077.     function _compile_plugin_call($type, $name) {
  2078.         if (isset($this->_plugins[$type][$name])) {
  2079.             /* plugin loaded */
  2080.             if (is_array($this->_plugins[$type][$name][0])) {
  2081.                 return ((is_object($this->_plugins[$type][$name][0][0])) ?
  2082.                         "\$this->_plugins['$type']['$name'][0][0]->"    /* method callback */
  2083.                         : (string)($this->_plugins[$type][$name][0][0]).'::'    /* class callback */
  2084.                        ). $this->_plugins[$type][$name][0][1];
  2085.  
  2086.             } else {
  2087.                 /* function callback */
  2088.                 return $this->_plugins[$type][$name][0];
  2089.  
  2090.             }
  2091.         } else {
  2092.             /* plugin not loaded -> auto-loadable-plugin */
  2093.             return 'smarty_'.$type.'_'.$name;
  2094.  
  2095.         }
  2096.     }
  2097.  
  2098.     /**
  2099.      * load pre- and post-filters
  2100.      */
  2101.     function _load_filters()
  2102.     {
  2103.         if (count($this->_plugins['prefilter']) > 0) {
  2104.             foreach ($this->_plugins['prefilter'] as $filter_name => $prefilter) {
  2105.                 if ($prefilter === false) {
  2106.                     unset($this->_plugins['prefilter'][$filter_name]);
  2107.                     $_params = array('plugins' => array(array('prefilter', $filter_name, null, null, false)));
  2108.                     require_once(SMARTY_DIR . 'core' . DIRECTORY_SEPARATOR . 'core.load_plugins.php');
  2109.                     smarty_core_load_plugins($_params, $this);
  2110.                 }
  2111.             }
  2112.         }
  2113.         if (count($this->_plugins['postfilter']) > 0) {
  2114.             foreach ($this->_plugins['postfilter'] as $filter_name => $postfilter) {
  2115.                 if ($postfilter === false) {
  2116.                     unset($this->_plugins['postfilter'][$filter_name]);
  2117.                     $_params = array('plugins' => array(array('postfilter', $filter_name, null, null, false)));
  2118.                     require_once(SMARTY_DIR . 'core' . DIRECTORY_SEPARATOR . 'core.load_plugins.php');
  2119.                     smarty_core_load_plugins($_params, $this);
  2120.                 }
  2121.             }
  2122.         }
  2123.     }
  2124.  
  2125.  
  2126.     /**
  2127.      * Quote subpattern references
  2128.      *
  2129.      * @param string $string
  2130.      * @return string
  2131.      */
  2132.     function _quote_replace($string)
  2133.     {
  2134.         return strtr($string, array('\\' => '\\\\', '$' => '\\$'));
  2135.     }
  2136.  
  2137.     /**
  2138.      * display Smarty syntax error
  2139.      *
  2140.      * @param string $error_msg
  2141.      * @param integer $error_type
  2142.      * @param string $file
  2143.      * @param integer $line
  2144.      */
  2145.     function _syntax_error($error_msg, $error_type = E_USER_ERROR, $file=null, $line=null)
  2146.     {
  2147.         $this->_trigger_fatal_error("syntax error: $error_msg", $this->_current_file, $this->_current_line_no, $file, $line, $error_type);
  2148.     }
  2149.  
  2150.  
  2151.     /**
  2152.      * check if the compilation changes from cacheable to
  2153.      * non-cacheable state with the beginning of the current
  2154.      * plugin. return php-code to reflect the transition.
  2155.      * @return string
  2156.      */
  2157.     function _push_cacheable_state($type, $name) {
  2158.         $_cacheable = !isset($this->_plugins[$type][$name]) || $this->_plugins[$type][$name][4];
  2159.         if ($_cacheable
  2160.             || 0<$this->_cacheable_state++) return '';
  2161.         if (!isset($this->_cache_serial)) $this->_cache_serial = md5(uniqid('Smarty'));
  2162.         $_ret = 'if ($this->caching) { echo \'{nocache:'
  2163.             . $this->_cache_serial . '#' . $this->_nocache_count
  2164.             . '}\';}';
  2165.         return $_ret;
  2166.     }
  2167.  
  2168.  
  2169.     /**
  2170.      * check if the compilation changes from non-cacheable to
  2171.      * cacheable state with the end of the current plugin return
  2172.      * php-code to reflect the transition.
  2173.      * @return string
  2174.      */
  2175.     function _pop_cacheable_state($type, $name) {
  2176.         $_cacheable = !isset($this->_plugins[$type][$name]) || $this->_plugins[$type][$name][4];
  2177.         if ($_cacheable
  2178.             || --$this->_cacheable_state>0) return '';
  2179.         return 'if ($this->caching) { echo \'{/nocache:'
  2180.             . $this->_cache_serial . '#' . ($this->_nocache_count++)
  2181.             . '}\';}';
  2182.     }
  2183.  
  2184.  
  2185.     /**
  2186.      * push opening tag-name, file-name and line-number on the tag-stack
  2187.      * @param string the opening tag's name
  2188.      */
  2189.     function _push_tag($open_tag)
  2190.     {
  2191.         array_push($this->_tag_stack, array($open_tag, $this->_current_line_no));
  2192.     }
  2193.  
  2194.     /**
  2195.      * pop closing tag-name
  2196.      * raise an error if this stack-top doesn't match with the closing tag
  2197.      * @param string the closing tag's name
  2198.      * @return string the opening tag's name
  2199.      */
  2200.     function _pop_tag($close_tag)
  2201.     {
  2202.         $message = '';
  2203.         if (count($this->_tag_stack)>0) {
  2204.             list($_open_tag, $_line_no) = array_pop($this->_tag_stack);
  2205.             if ($close_tag == $_open_tag) {
  2206.                 return $_open_tag;
  2207.             }
  2208.             if ($close_tag == 'if' && ($_open_tag == 'else' || $_open_tag == 'elseif' )) {
  2209.                 return $this->_pop_tag($close_tag);
  2210.             }
  2211.             if ($close_tag == 'section' && $_open_tag == 'sectionelse') {
  2212.                 $this->_pop_tag($close_tag);
  2213.                 return $_open_tag;
  2214.             }
  2215.             if ($close_tag == 'foreach' && $_open_tag == 'foreachelse') {
  2216.                 $this->_pop_tag($close_tag);
  2217.                 return $_open_tag;
  2218.             }
  2219.             if ($_open_tag == 'else' || $_open_tag == 'elseif') {
  2220.                 $_open_tag = 'if';
  2221.             } elseif ($_open_tag == 'sectionelse') {
  2222.                 $_open_tag = 'section';
  2223.             } elseif ($_open_tag == 'foreachelse') {
  2224.                 $_open_tag = 'foreach';
  2225.             }
  2226.             $message = " expected {/$_open_tag} (opened line $_line_no).";
  2227.         }
  2228.         $this->_syntax_error("mismatched tag {/$close_tag}.$message",
  2229.                              E_USER_ERROR, __FILE__, __LINE__);
  2230.     }
  2231.  
  2232. }
  2233.  
  2234. /**
  2235.  * compare to values by their string length
  2236.  *
  2237.  * @access private
  2238.  * @param string $a
  2239.  * @param string $b
  2240.  * @return 0|-1|1
  2241.  */
  2242. function _smarty_sort_length($a, $b)
  2243. {
  2244.     if($a == $b)
  2245.         return 0;
  2246.  
  2247.     if(strlen($a) == strlen($b))
  2248.         return ($a > $b) ? -1 : 1;
  2249.  
  2250.     return (strlen($a) > strlen($b)) ? -1 : 1;
  2251. }
  2252.  
  2253.  
  2254. /* vim: set et: */
  2255.  
  2256. ?>
  2257.